<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
<script>
    //找到一段话里最短的单词长度
    function findShort(s) {
        var arr = s.split(" "),arr2= [];
        arr.forEach(function (item) {
            arr2.push(item.length);
        });
        return Math.min.apply(null,arr2);
    }
//    console.log(findShort("and short leg logn ago shit who a"));

    //泰伯那切数列
    //1 1 1 3 5 9 17
    //第一种方法
//   function tribonacci(signature, n) {
//       while(signature.length<n){
//           signature.push(signature.slice(-3).reduce(function (prev, next) {return prev+next; }));
//       }
//       return signature.slice(0, n);
//   }
    /*reduce是数组的归并方法*/
    //第二种方法
//    function tribonacci(signature, n) {
//        if(signature.length<n){
//            for(var i=signature.length; i<n; i++){
//                signature.push(signature[i-1]+signature[i-2]+signature[i-3]);
//            }
//            return signature;
//        }else{
//            return signature.slice(0,n);
//        }
//    }

    //找到偶数组中的为一个奇数或者奇数组中唯一的偶数
    function findOutlier(integers) {
        //第一种方法
//        var even=integers.filter(function (item) {
//            return item%2 === 0;
//        });
//        var odd =integers.filter(function (item) {
//            return item%2 !== 0;
//        });
//        if(odd.length===1){
//            return odd[0];
//        }else if(even.length===1){
//            return even[0];
//        }
        //简写版本
        var odd=[],even=[];
        for(var i=0; i<integers.length; i++){
            integers[i]%2 === 0 ? even.push(integers[i]): odd.push(integers[i]);
        }
        return even.length === 1 ? even[0] : odd[0];
    }

    //找一找一个数字是否可以由n^3+(n-1)^3+...+2^3+1^3组成，并返回这个n
    function findNB(m) {
        //第一种方法
//        var n=1, temp=0;
//        while(temp<m){
//            temp+= Math.pow(n, 3);
//            n++;
//        }
//        if(temp===m){
//            return n;
//        }else{
//            return -1;
//        }
        //第二种方法
        var n = 0;
        while (m > 0) {
            m -= ++n**3;
        }
        return m ? -1 : n;

    }
    //帮助小明找出一串偶数数字里的奇数的index或者一串奇数数字里的偶数的Index
    function iqTest(numbers){
        // ...
//        var arr = numbers.split(" ");
//        var odd=[], even=[],index1=[],index2=[];
//        arr.forEach(function (p1) {
//            if(p1%2 === 0){
//                even.push(p1);
//                index1.push(arr.indexOf(p1));
//            }else{
//                odd.push(p1);
//                index2.push(arr.indexOf(p1));
//            }
//        });
//         return even.length===1?index1[0]+1:index2[0]+1;
        //精简一下语言
        var arr = numbers.split(" ").map(function (item) {
            return parseInt(item, 10);
        });
        var odd = arr.filter(function (item){
            return item%2 !== 0;
        });
        var even = arr.filter(function (item){
            return item%2 === 0;
        });
        return odd.length>even.length ? arr.indexOf(even[0])+1 : arr.indexOf(odd[0])+1;

    }

    //槌球俱乐部的高级会员满足年龄大于等于55岁，handicap值大于7
    function openOrSenior(data){
        // ...
        //data格式为[[a,b],[a,b],[a,b],[a,b]]
        var rank=[];
//        for(var i=0; i<data.length; i++){
//            if(data[i][0]>=55 && data[i][1]>7){
//                rank.push("Senior");
//            }else{
//                rank.push("Open");
//            }
//        }
       data.map(function (item) {
            if(item[0]>=55&&item[1]>7){
                 rank.push("Senior");
            }else{
                 rank.push("Open");
            }

        });
        return rank;
    }

    //处理ATM机的PIN密码,要求为4到6位的数字
    function validatePIN (pin) {
        //return true or false
        var pattern = /\d{4,6}/g;
        return pattern.test(pin);
    }

    //要求
    /* accum("abcd");    // "A-Bb-Ccc-Dddd"
     * accum("RqaEzty"); // "R-Qq-Aaa-Eeee-Zzzzz-Tttttt-Yyyyyyy"
     * accum("cwAt");    // "C-Ww-Aaa-Tttt"
     */
    //看的别人的代码，真的机智的飞起
    function accum(s) {
        // your code
        var final = s.split("").map(function (x,index) {
            return x.toUpperCase()+Array(index+1).join(x.toLowerCase());
        });
        return final.join("-");
    }

    //去除歌词里的某一个重复出现的word
    function songDecoder(song){
        // ...
        if(song.length<=200 && /[A-Z]+/g.test(song)){
            var pat = /WUB/g;
            var pat1 = /\s+/g;
           return song.replace(pat, " ").replace(pat1, " ").trim();
        }
    }

    //我们列出所有低于10的自然数，这是3或5的倍数，我们得到3，5，6和9.这些倍数的总和是23。

    //找出小于number的并且满足是3或者5的倍数的数字，将他们相加得到一个值，将该值输出

    function solution(number){
        var sum = 0;

        for(var i = 1;i< number; i++){
            if(i % 3 == 0 || i % 5 == 0){
                sum += i;
            }
        }
        return sum;
    }

    //找出所谓的isogram，词中每一个字母都不一样，如果一个字母出现两次及以上，则不是isogram
    function isIsogram(str) {
        //...
        return !/([a-zA-Z])(\1)+/gi.test(string) || str.length===0;
    }

    //创建一个名为除数/除数的函数，该函数采用一个整数，并返回一个包含整数除数的数组（除了1和数字本身）。
    // 如果数字为素数，则返回字符串'

    function divisors(integer) {
        var arr=[];
        for(var i = 2; i<=Math.ceil(integer/2); i++){
            if(integer%i === 0) {
                arr.push(i);
            }
        }
        if(arr.length === 0){
            return integer + ' is a prime';
        }else{
            return arr;
        }
    }
//false as 1+10 > 10
    //判断洋葱数组
    function isOnionArray(arr) {

//        if(arr.length>2){
//            var i=Math.floor(arr.length/2)-1;
//            var k=Math.floor(arr.length/2)+1;
//            var flag=[];
//            for(; i>=0; i--){
//                flag.push(arr[i]+arr[k++]);
//                if(k>=arr.length){
//                    break;
//                }
//        }
//        return flag.every(function(item){
//            return item<=10;
//        });
//    }else if(arr.length === 0 || (arr.length === 1 && arr[0]<= 10)){
//        return true;
//    }else if((arr.length === 2)&&(arr.reduce(function (prev, next) {
//        return prev+next;
//    }))<=10){
//        return true;
//}
        if (arr.length === 0 || (arr.length === 1 && arr[0] <= 10)) {
            return true;
        } else if (arr.length === 2) {
            var sum = arr[0]+arr[1];
            return sum<=10 ? true : false;
        } else if (arr.length > 2) {
            var i = Math.floor(arr.length / 2) - 1;
            var k = Math.floor(arr.length / 2) + 1;
            var flag = [];
            for (; i >= 0; i--) {
                flag.push(arr[i] + arr[k++]);
                if (k >= arr.length) {
                    break;
                }
            }
            return flag.every(function (item) {
                return item <= 10;
            });
        }
    }
//console.log(isOnionArray([1,0,-1,2,5,30]));
//    [] [1,2,3] [1,2] [1,10]

    //题目要求，有n个窗口，数组customers中每一个数字代表一个顾客到的接待时间，按顺序为一个队列
    //问，当有n个窗口时，接待完数组中所有的顾客需要多长时间
    
    function findTime(customers, n) {
        //codeWars大佬的答案,ES6
//        var w = new Array(n).fill(0);
//        console.log(w);
//        for (var t of customers) {
//            var idx = w.indexOf(Math.min(...w));
//            console.log(idx);
//            w[idx] += t;
//            console.log(w[idx]);
//            console.log(w);
//        }
//        return Math.max(...w);
        //自己对照自己写的垃圾
        var arr = new Array(n);
        //设置n个窗口，每一个窗口目前都没有人，所以等待时间是0
        arr=arr.map(function (item) {
           item = 0;
        });
        //找到等待时间最短的一个窗口
        for(var j=0; j<customers.length ; j++){
            var arrMin = Math.min.apply(null, arr);
            var arrMinIdx = arr.indexOf(arrMin);
            arr[arrMinIdx] += customers[j];
            //原来的顾客离开，刚进来的顾客的事件为customer[j]，加起来就是该窗口迄今总的等待时间
        }
        return Math.max.apply(null, arr);
    }

   //给一个正整数num，它的位数至少为1位，当它为999这样的数时，对其进行如下操作，9*9*9=729 7*2*9=126
    //1*2*6=12 1*2=2,直到得到的数为一位时，就结束并返回操作次数

    function persistence(num) {
        //code me
        //codewars大佬代码
//        var times = 0;
//
//        num = num.toString();
//
//        while (num.length > 1) {
//            times++;
//            num = num.split('').map(Number).reduce((a, b) => a * b).toString();
//        }
//
//        return times;

//我的垃圾
        var k=0;
        var str = num.toString();
        while(str.length>1){
            var arr = str.split("").map(function(item){return parseInt(item, 10);});
            k++;
            str = arr.reduce(function(a, b){return a*b;}).toString();
        }
        return k;

    }


    //a[0] = a[1] + a[2] = a[3] + a[4] + a[5] = a[6] + a[7] + a[8] + a[9] = ...
    //满足以上条件的就是Madhav array
    //数组长度为0 或者1的不满足条件，不算在内
    function isMadhavArray(arr) {
        var i=1, sum=[];
        var arr = arr.map(function (item) {
            return parseInt(item,10);
        });
        var firstVal=arr[0];
        var len=[];
        if(arr.length === 0 || arr.length === 1){
            return false;
        }else if(arr.length === 2){
            return false;
        }else{
            while(arr.length>0){
                var removed = arr.splice(0,i);
                len.push(removed);
                sum.push(removed.reduce(function(a,b){return a+b;}));
                i++;
            }
            if(len[len.length-1].length !== len.length){
                return false;
            }
            return sum.every(function(item){return (item === firstVal);});
        }
    }
//自己问一下自己，如何判断一个数组里面所有的元素都是一样的，这个数组里可能会出现字符串
    function sameArr(arr){
        var val = arr[0];
        if(arr.length ===0 || arr.length ===1){
            return false;
        }
        return arr.every(function (item) {
            return item===val;
        });

    }

    //如何判断一个等差数列
    function equalDiff(arr){
        var temp=arr[0],diff,d=[];
        for(var i=1; i<arr.length; i++ ){
                diff = arr[i]-temp;
                temp=arr[i];
                d.push(diff);

        }
        return sameArr(d);

    }

    //打印钻石
    /*
    *             *
   * 3对应       ***
    *             *
    *
    * */
    function diamond(n){
        if(n%2 === 0 || n<1){
            return null;
        }
        var str = '';
        for(var i=-Math.floor(n/2); i<=Math.floor(n/2); i++){
            str += space(Math.abs(i)) + star(n - 2 * Math.abs(i));
        }
        return str;
    }
    function space(x){
        var string = '', i = 0;
        while(i<x){
            string += " ";
            i++;
        }
        return string;
    }
    function star(y){
        var string = '', i = 0;
        while(i<y){
            string += "*";
            i++;
        }
        return string + '\n';
    }

    //除了利用绝对值以外，还可以考虑使用曲线圈住一片可用区域，然后设置可用区域内部点的曲线方程，最后打印出合适的图形
    //如下
    function star(n) {
        if(n%2 === 0 || n < 1){
            return null;
        }
        var str = '';
        var a = Math.floor(n/2);
        for(var i = -a; i <= a; i++){
            for(var j = -a; j <= a; j++){
                if(Math.abs(i)/a + Math.abs(j)/a > 1){
                    str += " ";
                }else{
                    str += "*";

                }
            }
            str+="\n";
        }
        return str;
    }

    /*uniqueInOrder('AAAABBBCCDAABBB') == ['A', 'B', 'C', 'D', 'A', 'B']
     uniqueInOrder('ABBCcAD')         == ['A', 'B', 'C', 'c', 'A', 'D']
     uniqueInOrder([1,2,2,3,3])       == [1,2,3]*/

    var uniqueInOrder=function(iterable){
        //your code here - remember iterable can be a string or an array
        if(!Array.isArray(iterable)){
            var iterable = iterable.split("");
        }
        var arr = [];
        //以下的代码适用于给数组查重，不允许结果出现相同的数组元素
//       for(var i = 0; i < iterable.length; i++){
//           if(arr.every(function(item){return item !== iterable[i];})){
//               arr.push(iterable[i]);
//           }
//       }
//而下一段代码适用于给数组查重，但是不在乎结果中是否还有重复元素
        for(var i = 0; i<iterable.length; i++){
            if(iterable[i] !== iterable[i-1]){
                arr.push(iterable[i]);
            }else{
                continue;
            }
        }
        return arr;

    }

    //输入100，那么结果为1=1+0+0；输入99，结果为18=9+9，
    //如果数组元素的权重相等，那么就对比他们的字符串大小，a.localeCompare(b);
    //如果a>b，返回1，a<b返回-1相等就返回0
    //那么"56 65 74 100 99 68 86 180 90" ordered by numbers weights becomes: "100 180 90 56 65 74 68 86 99"
    function orderWeight(strng){
        var arr = strng.split(" ").sort();
        arr.sort(function(x, y){
            if(getWeight(x)<getWeight(y)){
                return -1;
            }else if(getWeight(x) > getWeight(y)){
                return 1;
            }else if(getWeight(x) === getWeight(y)){
                if(x<y){
                    return -1;
                }else{
                    return 1;
                }
            }
        });
        return arr;
        /*codeWars大佬的代码，很是机智
        * return strng
         .split(" ")
         .map(function(v) {
         return {
         val: v,
         key: v.split("").reduce(function(prev, curr) {
         return parseInt(prev) + parseInt(curr);
         }, 0)
         };
         })
         .sort(function(a, b) {
         return a.key == b.key
         ? a.val.localeCompare(b.val)
         : (a.key - b.key);
         })
         .map(function(v) {
         return v.val;
         })
         .join(" ");*/
    }
    function getWeight(x) {
        var weight = 0;
        var arr = x.split("");
        arr.forEach(function(i) {
            weight += parseInt(i, 10);
        });
        return weight;
    }

    //2000 103 123 4444 99
console.log(orderWeight("2000 10003 1234000 44444444 9999 11 11 22 123"));
//2000 103 123 4444 99
    //11 11 2000 10003 22 123 1234000 44444444 9999
</script>

</body>
</html>
